// connect 用于将context 中的store及相关的方法注入到我们的组件中
import { connect } from 'react-redux'
import React, { Component } from 'react'
// 从redux的相关文件里导入state的定义
import { IProductInfo, getQuickSelect } from '@/modules/product'
import { SimpleImg } from 'react-simple-img'
import './style.less'

interface IStore {
  productInfo: IProductInfo
  [key: string]: any
}

interface IProps {
  productInfo: IProductInfo
  getQuickSelect: Function
}

interface IState {}

export class Index extends Component<IProps, IState> {
  state = {
    a: true,
  }

  componentDidMount() {
    this.props.getQuickSelect()
  }

  render() {
    return (
      <div>
        {this.props.productInfo.quickSelects.map(item => {
          return <SimpleImg height={500} src={item.pic} alt=""></SimpleImg>
        })}
      </div>
    )
  }
}

export default connect(({ productInfo }: IStore) => ({ productInfo }), {
  getQuickSelect,
})(Index)

// 两数之和（穷举法）
function twoSum(nums: Array<number>, target: number) {
  let i = 0 // 1次
  let j = 0 // 1次
  let result: any // 1次
  for (const n of nums) {
    // n次, n = nums.length
    j = 0 // n次
    for (const m of nums) {
      // n * n次
      if (n + m === target) {
        // n * n次
        result = {
          // 一次
          n,
          m,
        }
        break // 一次
      }
      j += 1 // n * n次
    }
    if (result) {
      // n次
      break // 一次
    }
    i += 1 // n次
  }
  console.log(i, j, result) // 一次
}
// 时间复杂度算法如下： 以每次计算耗时为unitTime为例
// T(n) = 1+1+1+n+n+n*n+n*n+1+n+1+n+1 = 6 + 4n + 2n²
// 套用算法复杂度公式计算，常数阶、线性阶以及平方阶，最终这里得到的值为O(n²)
// 空间复杂度在大多数情况下我们不会考虑

twoSum([2, 3, 4], 6)
twoSum([1, 2, 3, 4, 5, 6, 7, 8, 9], 11)

// 两数之和(排除法，用空间换时间)
function twoSum1(nums: Array<number>, target: number) {
  let i = 0
  let j = 0
  let result: any
  const obj = nums.reduce((prev: { [key: number]: number }, curr: number, index: number) => {
    // n次
    prev[curr] = index
    return prev
  }, {})
  for (const n of nums) {
    // n次
    j = target - n
    if (obj[j]) {
      result = { n, j }
      break
    }
    i += 1
  }
  console.log(i, obj[j], result)
}
// 最终的时间复杂度为O(n)

// 排除法(对算法2的优化)
